'use strict';
module.exports = {
	/**
	 * 获取用户信息
	 * @url client/user/kh/getUserInfo 前端调用的url参数地址
	 * data 请求参数
	 * @param {Boolean} is_attention_num  是否返回关注数（选填）
	 * @param {Boolean} is_fans_num  是否返回粉丝数（选填）
	 * @param {Boolean} is_visit_num  是否返回访问数（选填）
	 * @param {Boolean} is_article_all  是否返回全部文章数（选填）
	 * @param {Boolean} is_article_open  是否返回公开文章数（选填）
	 * @param {Boolean} is_article_secret  是否返回私密文章数（选填）
	 * @param {Boolean} is_article_audit  是否返回审核文章数（选填）
	 * @param {Boolean} is_article_draft  是否返回草稿文章数（选填） 
	 * @param {Boolean} is_article_praise  是否返回文章点赞总数（选填）
	 * @param {Boolean} is_article_remark  是否返回文章评论总数（选填）
	 * @param {Boolean} is_article_collect  是否返回文章收藏总数（选填）
	 * @param {Boolean} is_resource_all  是否返回全部资源数（选填）
	 * @param {Boolean} is_resource_audit  是否返回审核资源数（选填）
	 * @param {Boolean} is_resource_pass  是否返回通过资源数（选填）
	 * @param {Boolean} is_resource_refuse  是否返回拒绝资源数（选填） 
	 * @param {Boolean} is_invite_num  是否返回邀请总数（选填）
	 * @param {boolean} is_total_revenue 是否返回总收益（选填）
	 */
	main: async (event) => {
		let { data = {}, userInfo, util, filterResponse, originalParam } = event;
		let { customUtil, uniID, config, pubFun, vk, db, _ } = util;
		let { uid } = data;
		let res = { code: 0, msg: "" };
		// 业务逻辑开始-----------------------------------------------------------
		let {
			is_attention_num,
			is_fans_num,
			is_visit_num,
			is_article_all,
			is_article_open,
			is_article_secret,
			is_article_audit,
			is_article_draft,
			is_article_praise,
			is_article_remark,
			is_article_collect,
			is_resource_all,
			is_resource_audit,
			is_resource_pass,
			is_resource_refuse,
			is_invite_num,
			is_total_revenue
		} = data;
		
		let dbName = "uni-id-users";

		res["data"] = await vk.baseDao.findByWhereJson({
			dbName,
			getOne: true,
			getMain: true,
			whereJson: {
				_id: userInfo._id
			},
			fieldJson: {
				last_login_ip: false,
				last_login_date: false,
				client: false,
				token: false,
				register_date: false,
				register_env: false,
				wx_openid: false,
				dcloud_appid: false
			}
		})

		if (is_attention_num) {
			res.data["attention_num"] = await vk.baseDao.count({
				dbName: "db-attention",
				whereJson: {
					uid: userInfo._id
				}
			})
		}
		if (is_fans_num) {
			res.data["fans_num"] = await vk.baseDao.count({
				dbName: "db-fans",
				whereJson: {
					uid: userInfo._id
				}
			})
		}
		if (is_visit_num) {
			let num = 0;
			num += await vk.baseDao.sum({
				dbName: "db-article",
				fieldName: "visit_num", // 需要求和的字段名
				whereJson: {
					uid: userInfo._id
				}
			})

			num += await vk.baseDao.sum({
				dbName: "db-resource",
				fieldName: "visit_num", // 需要求和的字段名
				whereJson: {
					uid: userInfo._id
				}
			})

			res.data["visit_num"] = num;
		}

		if (is_article_all) {
			res.data["article_sum"] = await vk.baseDao.count({
				dbName: "db-article",
				whereJson: {
					uid: userInfo._id
				}
			})
		}
		if (is_article_open) {
			res.data["article_open_sum"] = await vk.baseDao.count({
				dbName: "db-article",
				whereJson: {
					uid: userInfo._id,
					issue_type: 1,
					status: 1
				}
			})
		}
		if (is_article_secret) {
			res.data["article_secret_sum"] = await vk.baseDao.count({
				dbName: "db-article",
				whereJson: {
					uid: userInfo._id,
					issue_type: 2
				}
			})
		}
		if (is_article_audit) {
			res.data["article_audit_sum"] = await vk.baseDao.count({
				dbName: "db-article",
				whereJson: {
					uid: userInfo._id,
					status: _.in([0, 2])
				}
			})
		}
		if (is_article_draft) {
			res.data["article_draft_sum"] = await vk.baseDao.count({
				dbName: "db-article",
				whereJson: {
					uid: userInfo._id,
					is_draft: 1
				}
			})
		}
		if (is_article_praise) {
			let num = 0;
			num += await vk.baseDao.sum({
				dbName: "db-article",
				fieldName: "praise_num", // 需要求和的字段名
				whereJson: {
					uid: userInfo._id
				}
			})
			
			num += await vk.baseDao.sum({
				dbName: "db-resource",
				fieldName: "praise_num", // 需要求和的字段名
				whereJson: {
					uid: userInfo._id
				}
			})
			
			res.data["praise_sum"] = num;
		}
		if (is_article_remark) {
			let num = 0;
			num += await vk.baseDao.sum({
				dbName: "db-article",
				fieldName: "remark_num", // 需要求和的字段名
				whereJson: {
					uid: userInfo._id
				}
			})
			
			num += await vk.baseDao.sum({
				dbName: "db-resource",
				fieldName: "remark_num", // 需要求和的字段名
				whereJson: {
					uid: userInfo._id
				}
			})
			
			res.data["remark_sum"] = num;
		}
		if (is_article_collect) {
			let num = 0;
			num += await vk.baseDao.sum({
				dbName: "db-article",
				fieldName: "collect_num", // 需要求和的字段名
				whereJson: {
					uid: userInfo._id
				}
			})
			
			num += await vk.baseDao.sum({
				dbName: "db-resource",
				fieldName: "collect_num", // 需要求和的字段名
				whereJson: {
					uid: userInfo._id
				}
			})
			
			res.data["collect_sum"] = num;
		}
		
		if (is_resource_all) {
			res.data["resource_sum"] = await vk.baseDao.count({
				dbName: "db-resource",
				whereJson: {
					uid: userInfo._id
				}
			})
		}
		if (is_resource_audit) {
			res.data["resource_audit_sum"] = await vk.baseDao.count({
				dbName: "db-resource",
				whereJson: {
					uid: userInfo._id,
					status: 0
				}
			})
		}
		if (is_resource_pass) {
			res.data["resource_pass_sum"] = await vk.baseDao.count({
				dbName: "db-resource",
				whereJson: {
					uid: userInfo._id,
					status: 1
				}
			})
		}
		if (is_resource_refuse) {
			res.data["resource_refuse_sum"] = await vk.baseDao.count({
				dbName: "db-resource",
				whereJson: {
					uid: userInfo._id,
					status: 2
				}
			})
		}
		if (is_invite_num) {
			res.data["invite_num"] = await vk.baseDao.count({
				dbName,
				whereJson: {
					superior_code: userInfo.my_invite_code
				}
			})
		}
		if (is_total_revenue) {
			let num = 0;
			num += await vk.baseDao.sum({
				dbName: "db-earnings-log",
				fieldName: "change_money", // 需要求和的字段名
				whereJson: {
					uid: userInfo._id
				}
			})
			res.data["total_revenue"] = num;
		}
		// 业务逻辑结束-----------------------------------------------------------
		return res;
	}
}